    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

q    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

O    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

W    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

H    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

>    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

W    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

B    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

V    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

B    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

N    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

9    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

9    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

4    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

q    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

O    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

N    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

4    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

8    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

7    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

5    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

O    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

N    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

C    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

4    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

8    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

6    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

4    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

*    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

V    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

B    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

N    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

2    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

H    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

C    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

C    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

4    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

C    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

3    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

F    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

N    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

*    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

*    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

*    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

V    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

P    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

!    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

M    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

I    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

E    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

A    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

L    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

>    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

/    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

>    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

U    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

D    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

w    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

x    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

+    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

G    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

S    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

#    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

C    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

=    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

c    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

k    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

m    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

{    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

0    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

1    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

'    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

}    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

@    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

y    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

-    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

>    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

T    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

[    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

]    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

:    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

R    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

h    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

"    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

b    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

(    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

p    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

r    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

_    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

v    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

a    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

,    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

     def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

f    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

l    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

o    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

n    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

g    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

t    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

u    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

d    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

.    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

s    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

i    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

z    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

e    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

)    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")


    def _load_data(self, time_slice: slice):
        """Load the dataset and select time period."""
        methods = [
            # Method 1: Simple anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {'anon': True},
                    'consolidated': True
                }
            },
            
            # Method 2: Direct HTTP access
            lambda: {
                'method': xr.open_zarr,
                'args': [fsspec.filesystem(
                    'http',
                    client_kwargs={
                        'trust_env': False,
                        'timeout': 30
                    }
                ).get_mapper(self.data_path.replace('gs://', 'https://storage.googleapis.com/'))],
                'kwargs': {'consolidated': True}
            },
            
            # Method 3: GCS anonymous access
            lambda: {
                'method': xr.open_zarr,
                'args': [gcsfs.GCSFileSystem(token='anon').get_mapper(self.data_path)],
                'kwargs': {'consolidated': True}
            },
            
            # Method 4: Configured timeouts
            lambda: {
                'method': xr.open_zarr,
                'args': [self.data_path],
                'kwargs': {
                    'storage_options': {
                        'anon': True,
                        'timeout': 30,
                        'retries': 10,
                        'default_fill_cache': False
                    },
                    'consolidated': True
                }
            }
        ]

        last_exception = None
        for method_factory in methods:
            try:
                method_info = method_factory()
                logger.info(f"Attempting to open dataset with method: {method_info}")
                self.ds = method_info['method'](
                    *method_info['args'],
                    **method_info['kwargs']
                )
                self.times = self.ds.time.sel(time=time_slice)
                print(f"Selected time period: {self.times[0].values} to {self.times[-1].values}")
                print(f"Variables: {self.variables}")
                print(f"Pressure levels: {self.pressure_levels}")
                return  # Success! Exit the method
                
            except Exception as e:
                last_exception = e
                logger.warning(f"Method failed with error: {str(e)}")
                continue
        
        # If we get here, all methods failed
        raise RuntimeError(f"All methods to load data failed. Last error: {str(last_exception)}")

